/*
 * Copyright 2006 The Android Open Source Project
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "src/shaders/SkBlendShader.h"

#include "config/SkUserConfig.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkBlender.h"
#include "include/core/SkData.h"
#include "include/core/SkFlattenable.h"
#include "include/effects/SkRuntimeEffect.h"
#include "src/base/SkArenaAlloc.h"
#include "src/core/SkBlendModePriv.h"
#include "src/core/SkBlenderBase.h"
#include "src/core/SkEffectPriv.h"
#include "src/core/SkRasterPipeline.h"
#include "src/core/SkRasterPipelineOpContexts.h"
#include "src/core/SkRasterPipelineOpList.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkRuntimeEffectPriv.h"
#include "src/core/SkWriteBuffer.h"
#include "src/shaders/SkShaderBase.h"

#if defined(SK_GRAPHITE)
#include "src/gpu/Blend.h"
#include "src/gpu/graphite/KeyHelpers.h"
#include "src/gpu/graphite/PaintParamsKey.h"
#endif

#include <optional>

sk_sp<SkFlattenable> SkBlendShader::CreateProc(SkReadBuffer& buffer) {
    RENDER_UNIMPLEMENTED;
    return nullptr;
//     sk_sp<SkShader> dst(buffer.readShader());
//     sk_sp<SkShader> src(buffer.readShader());
//     if (!buffer.validate(dst && src)) {
//         return nullptr;
//     }
//
//     unsigned mode = buffer.read32();
//
//     if (mode == kCustom_SkBlendMode) {
//         sk_sp<SkBlender> blender = buffer.readBlender();
//         if (buffer.validate(blender != nullptr)) {
//             return SkShaders::Blend(std::move(blender), std::move(dst), std::move(src));
//         }
//     } else {
//         if (buffer.validate(mode <= (unsigned)SkBlendMode::kLastMode)) {
//             return SkShaders::Blend(static_cast<SkBlendMode>(mode), std::move(dst), std::move(src));
//         }
//     }
//     return nullptr;
}

void SkBlendShader::flatten(SkWriteBuffer& buffer) const {
    RENDER_UNIMPLEMENTED;
    return;
//     buffer.writeFlattenable(fDst.get());
//     buffer.writeFlattenable(fSrc.get());
//     buffer.write32((int)fMode);
}

// Returns the output of e0, and leaves the output of e1 in r,g,b,a
// static float* append_two_shaders(const SkStageRec& rec,
//                                  const SkShaders::MatrixRec& mRec,
//                                  SkShader* s0,
//                                  SkShader* s1) {
//     struct Storage {
//         float fCoords[2 * SkRasterPipeline_kMaxStride];
//         float fRes0[4 * SkRasterPipeline_kMaxStride];
//     };
//     auto storage = rec.fAlloc->make<Storage>();
//
//     // Note we cannot simply apply mRec here and then unconditionally store the coordinates. When
//     // building for Android Framework it would interrupt the backwards local matrix concatenation if
//     // mRec had a pending local matrix and either of the children also had a local matrix.
//     // b/256873449
//     if (mRec.rasterPipelineCoordsAreSeeded()) {
//         rec.fPipeline->append(SkRasterPipelineOp::store_src_rg, storage->fCoords);
//     }
//     if (!as_SB(s0)->appendStages(rec, mRec)) {
//         return nullptr;
//     }
//     rec.fPipeline->append(SkRasterPipelineOp::store_src, storage->fRes0);
//
//     if (mRec.rasterPipelineCoordsAreSeeded()) {
//         rec.fPipeline->append(SkRasterPipelineOp::load_src_rg, storage->fCoords);
//     }
//     if (!as_SB(s1)->appendStages(rec, mRec)) {
//         return nullptr;
//     }
//     return storage->fRes0;
// }

bool SkBlendShader::appendStages(const SkStageRec& rec, const SkShaders::MatrixRec& mRec) const {
    RENDER_UNIMPLEMENTED;
    return false;
//     float* res0 = append_two_shaders(rec, mRec, fDst.get(), fSrc.get());
//     if (!res0) {
//         return false;
//     }
//
//     rec.fPipeline->append(SkRasterPipelineOp::load_dst, res0);
//     SkBlendMode_AppendStages(fMode, rec.fPipeline);
//     return true;
}

#if defined(SK_ENABLE_SKVM)
skvm::Color SkBlendShader::program(skvm::Builder* p,
                                   skvm::Coord device,
                                   skvm::Coord local,
                                   skvm::Color paint,
                                   const SkShaders::MatrixRec& mRec,
                                   const SkColorInfo& cinfo,
                                   skvm::Uniforms* uniforms,
                                   SkArenaAlloc* alloc) const {
    skvm::Color d, s;
    if ((d = as_SB(fDst)->program(p, device, local, paint, mRec, cinfo, uniforms, alloc)) &&
        (s = as_SB(fSrc)->program(p, device, local, paint, mRec, cinfo, uniforms, alloc))) {
        return p->blend(fMode, s, d);
    }
    return {};
}
#endif

#if defined(SK_GRAPHITE)
void SkBlendShader::addToKey(const skgpu::graphite::KeyContext& keyContext,
                             skgpu::graphite::PaintParamsKeyBuilder* builder,
                             skgpu::graphite::PipelineDataGatherer* gatherer) const {
    using namespace skgpu::graphite;

    BlendShaderBlock::BeginBlock(keyContext, builder, gatherer);

    as_SB(fSrc)->addToKey(keyContext, builder, gatherer);
    as_SB(fDst)->addToKey(keyContext, builder, gatherer);

    SkSpan<const float> porterDuffConstants = skgpu::GetPorterDuffBlendConstants(fMode);
    if (!porterDuffConstants.empty()) {
        CoeffBlenderBlock::BeginBlock(keyContext, builder, gatherer, porterDuffConstants);
        builder->endBlock();
    } else {
        BlendModeBlenderBlock::BeginBlock(keyContext, builder, gatherer, fMode);
        builder->endBlock();
    }

    builder->endBlock();  // BlendShaderBlock
}
#endif

sk_sp<SkShader> SkShaders::Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src) {
    RENDER_UNIMPLEMENTED;
    return nullptr;
//     if (!src || !dst) {
//         return nullptr;
//     }
//     switch (mode) {
//         case SkBlendMode::kClear:
//             return Color(0);
//         case SkBlendMode::kDst:
//             return dst;
//         case SkBlendMode::kSrc:
//             return src;
//         default:
//             break;
//     }
//     return sk_sp<SkShader>(new SkBlendShader(mode, std::move(dst), std::move(src)));
}

sk_sp<SkShader> SkShaders::Blend(sk_sp<SkBlender> blender,
                                 sk_sp<SkShader> dst,
                                 sk_sp<SkShader> src) {
    RENDER_UNIMPLEMENTED;
    return nullptr;
//     if (!src || !dst) {
//         return nullptr;
//     }
//     if (!blender) {
//         return SkShaders::Blend(SkBlendMode::kSrcOver, std::move(dst), std::move(src));
//     }
//     if (std::optional<SkBlendMode> mode = as_BB(blender)->asBlendMode()) {
//         return sk_make_sp<SkBlendShader>(mode.value(), std::move(dst), std::move(src));
//     }
//
// #ifdef SK_ENABLE_SKSL
//     // This isn't a built-in blend mode; we might as well use a runtime effect to evaluate it.
//     static SkRuntimeEffect* sBlendEffect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
//         "uniform shader s, d;"
//         "uniform blender b;"
//         "half4 main(float2 xy) {"
//             "return b.eval(s.eval(xy), d.eval(xy));"
//         "}"
//     );
//     SkRuntimeEffect::ChildPtr children[] = {std::move(src), std::move(dst), std::move(blender)};
//     return sBlendEffect->makeShader(/*uniforms=*/{}, children);
// #else
//     // We need SkSL to render this blend.
//     return nullptr;
// #endif
}

void SkRegisterBlendShaderFlattenable() {
//     SK_REGISTER_FLATTENABLE(SkBlendShader);
//     // Previous name
//     SkFlattenable::Register("SkShader_Blend", SkBlendShader::CreateProc);
}
